use std::string;

use serde_json::{Value, json, Map};
use sqlx::{MySql, MySqlPool, query_builder::QueryBuilder};
use common::{
    error::AppError,
    utils::date_util::date_is_query_format,// 假设使用之前的日期验证函数
    page::TableDataInfo,
};
use crate::coze_constants;

use super::{
    model::{        AddAiAgentPlatVo, 
        ListAiAgentPlatQuery,
        UpdateAiAgentPlatVo,
        AiAgentPlat,},
};
use tracing::error;


use super::super::utils::http_utils;
pub async fn select_ai_agent_plat_list(
    db: &MySqlPool,
    params: ListAiAgentPlatQuery,
) -> Result<TableDataInfo<AiAgentPlat>, AppError> {
    // 初始化查询构建器，使用参数化方式构建SQL
    let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new("SELECT * FROM ai_agent_plat WHERE 1=1 AND data_sta != 'D'");
    let mut count_builder: QueryBuilder<MySql> = QueryBuilder::new("SELECT count(*) FROM ai_agent_plat WHERE 1=1 AND data_sta != 'D'");

    // 处理名称查询条件 - 使用参数化LIKE查询
    if let Some(ai_agent_plat_name) = params.ai_agent_plat_name {
        let trimmed = ai_agent_plat_name.trim();
        if !trimmed.is_empty() {
            // 仅在非空时处理，避免空字符串导致的意外查询
            let like_pattern = format!("%{}%", trimmed);
            // 对两个构建器使用相同的参数化处理
            query_builder.push(" AND ai_agent_plat_name LIKE ?").push_bind(like_pattern.clone());
            count_builder.push(" AND ai_agent_plat_name LIKE ?").push_bind(like_pattern);
        }
    }

    // 处理账号名称查询条件 - 修复原代码中的字段名错误
    if let Some(ai_agent_plat_account_name) = params.ai_agent_plat_account_name {
        let trimmed = ai_agent_plat_account_name.trim();
        if !trimmed.is_empty() {
            let like_pattern = format!("%{}%", trimmed);
            // 原代码中这里错误地使用了ai_agent_plat_name，已修正为正确的字段名
            query_builder.push(" AND ai_agent_plat_account_name LIKE ?").push_bind(like_pattern.clone());
            count_builder.push(" AND ai_agent_plat_account_name LIKE ?").push_bind(like_pattern);
        }
    }

    // 处理开始时间条件 - 增加日期验证错误返回
    if let Some(begin_time) = params.begin_time {
        let trimmed = begin_time.trim();
        if !trimmed.is_empty() {
            // 日期验证失败时返回错误，而不是仅打印
            match date_is_query_format(trimmed) {
                Ok(()) => (),
                Err(e) => {
                    let errmsg = AppError::ValidationFailed(format!("基本错误,{}",e.to_string()));
                    return Err(errmsg);

                }
            }
            // date_is_query_format(trimmed)?;
            query_builder.push(" AND create_time >= ?").push_bind(trimmed.to_string());
            count_builder.push(" AND create_time >= ?").push_bind(trimmed.to_string());
        }
    }

    // 处理结束时间条件
    if let Some(end_time) = params.end_time {
        let trimmed = end_time.trim();
        if !trimmed.is_empty() {
            match date_is_query_format(trimmed) {
                Ok(()) => (),
                Err(e) => {
                    let errmsg = AppError::ValidationFailed(format!("基本错误,{}",e.to_string()));
                    return Err(errmsg);

                }
            }

            query_builder.push(" AND create_time <= ?").push_bind(trimmed.to_string());
            count_builder.push(" AND create_time <= ?").push_bind(trimmed.to_string());
        }
    }

    // 执行总数查询
    let total: (i64,) = count_builder
        .build_query_as()
        .fetch_one(db)
        .await
        .map_err(|e| {
            error!("[DB_ERROR] 统计AI代理平台总数失败: {}", e);
            AppError::from(e)
        })?;

    // 处理分页参数 - 确保参数合法
    let page_num = params.page_num.unwrap_or(1).max(1); // 页码至少为1
    let page_size = params.page_size.unwrap_or(10).clamp(1, 100); // 限制每页条数在1-100之间
    let offset = (page_num - 1) * page_size;

    // 添加排序和分页 - 使用参数化绑定分页参数
    query_builder
        .push(" ORDER BY ai_agent_plat_id ASC, created_time DESC LIMIT ")
        .push_bind(page_size)
        .push(" OFFSET ")
        .push_bind(offset);


    println!("page_size:{}", page_size);
    println!("offset:{}", offset);
    println!("sql:{}", query_builder.sql());
    // 执行列表查询
    let rows = query_builder
        .build_query_as()
        .fetch_all(db)
        .await
        .map_err(|e| {
            error!("[DB_ERROR] 查询AI代理平台列表失败: {}", e);
            AppError::from(e)
        })?;

    Ok(TableDataInfo::new(rows, total.0))
}



/// 根据ID查询详情
pub async fn select_ai_agent_plat_by_id(db: &MySqlPool, ai_agent_plat_id: u64) -> Result<AiAgentPlat, AppError> {
    let ai_agent_plat = sqlx::query_as!(
        AiAgentPlat,
        "SELECT * FROM ai_agent_plat WHERE ai_agent_plat_id = ?",
        ai_agent_plat_id
    )
        .fetch_one(db)
        .await?;
    Ok(ai_agent_plat)
}

/// 删除部门（逻辑删除）
pub async fn delete_ai_agent_plat_by_id(db: &MySqlPool, ai_agent_plat_id: u64) -> Result<u64, AppError> {
    // RuoYi 的删除是逻辑删除，更新 del_flag 字段
    let result = sqlx::query!(
        "UPDATE ai_agent_plat SET data_sta = 'D' WHERE ai_agent_plat_id = ?",
        ai_agent_plat_id
    )
        .execute(db)
        .await?;

    Ok(result.rows_affected())
}

pub async fn add_ai_agent_plat(db: &MySqlPool, ai_agent_plat: AddAiAgentPlatVo, user_name:&str) -> Result<u64, AppError> {
    let result = sqlx::query!(
        r#"
            INSERT INTO ai_agent_plat (
            ai_agent_plat_name, 
            ai_agent_plat_account_name, 
            ai_agent_plat_access_token, 
            ai_agent_plat_workspace_name, 
            ai_agent_plat_workspace_id, 
            created_by)
            VALUES (?, ?, ?, ?, ?, ?)
        "#,
        &ai_agent_plat.ai_agent_plat_name,
        &ai_agent_plat.ai_agent_plat_account_name,
        &ai_agent_plat.ai_agent_plat_access_token,
        &ai_agent_plat.ai_agent_plat_workspace_name,
        &ai_agent_plat.ai_agent_plat_workspace_id,
        user_name
    )
        .execute(db)
        .await?;

    Ok(result.rows_affected())
}

pub async fn update_ai_agent_plat(db: &MySqlPool, ai_agent_plat_vo: UpdateAiAgentPlatVo, user_name:&str) -> Result<u64, AppError> {

    let result = sqlx::query!(
        r#"
            UPDATE ai_agent_plat
            SET ai_agent_plat_name = ?, 
            ai_agent_plat_account_name = ?, 
            ai_agent_plat_access_token = ?, 
            ai_agent_plat_access_token_sta = null, 
            ai_agent_plat_workspace_name = ?, 
            ai_agent_plat_workspace_id = ?, 
            updated_by = ?, 
            data_sta = 'U'
            WHERE ai_agent_plat_id = ?
        "#,
        ai_agent_plat_vo.ai_agent_plat_name,
        ai_agent_plat_vo.ai_agent_plat_account_name,
        ai_agent_plat_vo.ai_agent_plat_access_token,
        ai_agent_plat_vo.ai_agent_plat_workspace_name,
        ai_agent_plat_vo.ai_agent_plat_workspace_id,
        user_name,
        ai_agent_plat_vo.ai_agent_plat_id
    )
    .execute(db)
    .await?;
    Ok(result.rows_affected())
}





pub async fn get_ai_agent_plat_workspace_id(ai_agent_plat_access_token : &str) -> Result<Value, AppError> {
    if ai_agent_plat_access_token.is_empty() {
        let errmsg = AppError::ValidationFailed("ai_agent_plat_access_token 为空".to_string());
        return Err(errmsg);
    }
    let way:&str = "get";
    let url:&str = "https://api.coze.cn/v1/workspaces";
    let token: String = "Bearer ".to_string() + 
    ai_agent_plat_access_token;

    let headers = coze_constants::with_auth_headers(&token);
    // 调用 request_json 并手动处理 Result
    let result = http_utils::request_json(way, url, headers, None).await;
    match result {
        Ok(data) => {
            // 成功：处理返回的 JSON 数据（data1 是 Value 类型）
            let pretty_json = serde_json::to_string_pretty(&data)?;
            println!("请求成功: {:?}", pretty_json);

                // 1. 安全提取 workspaces 数组（避免 unwrap() 直接 panic）
            let workspaces = data
                .get("data") // 获取顶层 "data" 字段（Option<&Value>）
                .ok_or_else(|| AppError::ValidationFailed("未找到 data 字段".to_string()))? // 字段缺失报错
                .get("workspaces") // 获取 "workspaces" 字段
                .ok_or_else(|| AppError::ValidationFailed("未找到 workspaces 字段".to_string()))?
                .as_array() // 转为数组（Option<&Vec<Value>>）
                .ok_or_else(|| AppError::ValidationFailed("workspaces 不是数组类型".to_string()))?;
                // 2. 循环遍历数组，提取每个元素的 id
                let mut new_array = Vec::new();
                for workspace in workspaces {
                    // 确保当前元素是 JSON 对象
                    let obj = workspace.as_object()
                        .ok_or_else(|| AppError::ValidationFailed("元素不是 JSON 对象".to_string()))?;
                    // 提取 id 和 name（允许缺失，可根据需求调整是否报错）
                    let id = obj.get("id").cloned();  // 克隆 Value 保留原始类型（数字/字符串）
                    let name = obj.get("name").cloned();
                    // 构建只包含 id 和 name 的新对象
                    let mut new_obj = Map::new();
                    if let Some(id_val) = id {
                        new_obj.insert("id".to_string(), id_val);
                    }
                    if let Some(name_val) = name {
                        new_obj.insert("name".to_string(), name_val);
                    }

                    // 跳过既没有 id 也没有 name 的对象（可选）
                    if !new_obj.is_empty() {
                        new_array.push(Value::Object(new_obj));
                    }





                    // let mut ids = Vec::new();
                    // // 提取当前 workspace 的 id 字段（支持 String 或数字类型）
                    // let id = workspace
                    //     .get("id")
                    //     .and_then(|v| {
                    //         // 统一统一处理：先尝试字符串，再尝试数字，统一转为 String
                    //         v.as_str()
                    //             .map(|s| s.to_string())
                    //             .or_else(|| v.as_u64().map(|n| n.to_string()))
                    //     })
                    //     .ok_or_else(|| AppError::ValidationFailed("id 不是不支持的类型（需为字符串或数字）".to_string()))?;

                    // ids.push(id.to_string());
                }
            

            return Ok(Value::Array(new_array));
        }
        Err(e) => {
            // 失败：处理错误（如打印日志）
            eprintln!("请求失败: {}", e);
            let errmsg = AppError::ValidationFailed(format!("基本错误,{}",e.to_string()));
            return Err(errmsg);
            // 也可以选择忽略错误（不推荐，可能隐藏问题）
            // return; // 提前返回
        }
    }

}





pub async fn get_ai_agent_plat_access_token_sta(db: &MySqlPool,ai_agent_plat_id : u64) -> Result<(), AppError> {
    // curl -X GET 'https://api.coze.cn/v1/bots?' \
    // -H "Authorization: Bearer cztei_qwceiQbGr6CR0GkdnLiTuo6d2XS3VbHseO7pxpsG1u9uO6De2OipJuH3Tzh2w7OKx" \
    // -H "Content-Type: application/json"
        // 1. 构建动态 JSON 对象（类似 JSONObject）
    // let mut product = json!({
    //     "id": 1001,
    //     "name": "Rust 编程指南",
    //     "price": 59.9,
    //     "in_stock": true,
    //     "tags": ["programming", "rust", "book"],
    //     "details": {
    //         "author": "张三",
    //         "publisher": "技术出版社"
    //     }
    // });

    // // 2. 访问基本字段
    // println!("产品名称: {}", product["name"].as_str().unwrap());
    // println!("价格: {}", product["price"].as_f64().unwrap());
    // println!("是否有货: {}", product["in_stock"].as_bool().unwrap());

    // // 3. 访问数组
    // let tags = product["tags"].as_array().unwrap();
    // println!("标签数量: {}", tags.len());
    // println!("第一个标签: {}", tags[0].as_str().unwrap());

    // // 4. 访问嵌套对象
    // let author = product["details"]["author"].as_str().unwrap();
    // println!("作者: {}", author);

    // // 5. 修改字段值
    // product["price"] = json!(49.9); // 降价
    // product["in_stock"] = json!(false); // 缺货
    // println!("修改后价格: {}", product["price"]);

    // // 6. 添加新字段
    // product["discount"] = json!(0.1); // 折扣
    // product["details"]["publish_date"] = json!("2023-01-01");
    // println!("新增折扣: {}", product["discount"]);

    // // 7. 转换为格式化的 JSON 字符串
    // let pretty_json = serde_json::to_string_pretty(&product)?;
    // println!("\n完整 JSON:\n{}", pretty_json);

    // Ok(())

    let ai_agent_plat =select_ai_agent_plat_by_id(db, ai_agent_plat_id).await?;

    let way:&str = "get";
    let url:&str = "https://api.coze.cn/v1/bots?";
    let token: String = "Bearer ".to_string() + 
    ai_agent_plat.ai_agent_plat_access_token.as_ref()
        .expect("access_token 为空");

    let headers = coze_constants::with_auth_headers(&token);
    // 调用 request_json 并手动处理 Result
    let result = http_utils::request_json(way, url, headers, None).await;
    match result {
        Ok(data) => {
            // 成功：处理返回的 JSON 数据（data1 是 Value 类型）
            println!("请求成功: {:?}", data);
            // 可以在这里对 data1 进行后续处理（如提取字段、存储等）
        }
        Err(e) => {
            // 失败：处理错误（如打印日志）
            eprintln!("请求失败: {}", e);
            let errmsg = AppError::ValidationFailed(format!("基本错误,{}",e.to_string()));
            return Err(errmsg);
            // 也可以选择忽略错误（不推荐，可能隐藏问题）
            // return; // 提前返回
        }
    }

    return  Ok(());
}